FEXPNetworkWinSocket.h

Go to the documentation of this file.

// © FEXP, FEXPEnterprise Solver, Ing. Vaclav Rek
// Windows socket communication.
// Compiler must support C++ ver.14 and later
#ifndef _CFEXPWINDOWSSOCKET_H_
#define _CFEXPWINDOWSSOCKET_H_
#include "FEXPCommon.h"
#include "FEXPConcurency.h"
#include "FEXPNetworkInterface.h"

#define SERVER_CLIENT_DEFINITION        CFEXPNetServerWinClient
#define SERVER_CLIENT_THREAD_DEFINITION CFEXPCppThread<void(Ptr<SERVER_CLIENT_DEFINITION>), Ptr<SERVER_CLIENT_DEFINITION>>

// Need to link with Ws2_32.lib
#pragma comment(lib, "ws2_32.lib")

// Windows OS -- setting
#define WININVSCK    INVALID_SOCKET // invalid socket
#define WINSOCKET    MAKEWORD(2, 2) // the highest version of Windows Sockets specification that the caller can use. The high-order byte specifies the minor version number; the low-order byte specifies the major version number.
#define WINPR_TCP       IPPROTO_TCP // TCP communication protocol
//#define WINPR_DMY       IPPROTO_IP // dummy for IP
#define WINSCTYPE       SOCK_STREAM // stream socket
#define WINNETWRK           AF_INET // internetwork protocols: UDP, TCP, etc.
#define WINNONADR                 0 // erro for non-legitimate Internet address
#define WINANYADR        INADDR_ANY
#define WINSOCSDW           SD_BOTH // 0x02 -- manifest constants for shutdown()


class CFEXPNetWinErrors
{
public:
  // [no public members   ] -----------------------------
protected:
  static std::map<int, const std::string> CONNECTION_ERRORS_1;
  static std::map<int, const std::string> CONNECTION_ERRORS_2;
  static std::map<int, const std::string> CONNECTION_ERRORS_3;
  static std::map<int, const std::string> CONNECTION_ERRORS_4;
  static std::map<int, const std::string> CONNECTION_ERRORS_5;
private:
  // [no private members  ] -----------------------------
};

#define MAX_MSG_IN_LEN 0x1000 // 1 x 4096 [B]
#define MAX_MSG_OT_LEN 0x1000 // 1 x 4096 [B]

class CFEXPNETWinMessage
{
public:
  using REQUEST =
    struct rqs_msg
  {
    char       record[MAX_MSG_IN_LEN]; // message content
    rqs_msg() { set_to_default(); }
    void set_to_default () { memset((void*)&record, FEXPCOMMON_ZERO_END_CHAR, sizeof(record)); }
    void set_data_to_send(const std::string & data) { set_to_default(); data.copy((char*)record, MAX_MSG_IN_LEN); }
  };
  using RESPONSE =
    struct rsp_msg
  {
    char       record[MAX_MSG_OT_LEN]; // message content
    rsp_msg() { set_to_default(); }
    void        set_to_default() { memset((void*)&record, FEXPCOMMON_ZERO_END_CHAR, sizeof(record)); }
    std::string get_send_data () { return CFEXPBaseConvers::StrTrim(std::string((char*)record)); }
  };

  // for win socket communication
  static t_ENetMessage WinSocketDataRead (SOCKET socket, CFEXPNETWinMessage::REQUEST & request, CFEXPNETWinMessage::RESPONSE & response, t_ModelData & data);
  static void          WinSocketDataWrite(SOCKET socket, CFEXPNETWinMessage::REQUEST & request, CFEXPNETWinMessage::RESPONSE & response, t_ModelData & data, t_ENetMessage message);
protected:
  // for win socket communication
  static bool          win_write_to_socket (REQUEST  & request , SOCKET socket, const std::string        & send_data);
  static t_ENetMessage win_read_from_Socket(RESPONSE & response, SOCKET socket, std::vector<std::string> & read_data);
private:
  // [no private members  ] -----------------------------
};


class CFEXPNetClientWinSocketConnection
  : public ICFEXPNetClientNodeService, public ICFEXPNetNodeConnection, public CFEXPNetWinErrors
{
public:
  CFEXPNetClientWinSocketConnection(size_t client_id, std::string server_ip, size_t port,
    std::function<void(std::function<void(size_t)>, ICFEXPNetClientNodeService &)> main);
  virtual ~CFEXPNetClientWinSocketConnection();

  // override pure virtual member functions
  virtual void Run  () override;
  virtual void Close() override;
  // override pure virtual member functions -- service
  virtual Ptr<std::map<size_t, Ptr<t_ModelData>>> ReadInstruction()                                                       override;
  virtual void                                    SendInstruction(size_t message, Ptr<t_ModelData> data)                  override;
  virtual Ptr<t_ModelData>                        GetMacroModelData()                                                     override;
  virtual void                                    AddMacroModelData(const t_ModelDataKey & key, Ptr<t_ModelDataDta> data) override;
  virtual Ptr<t_ModelDataDta>                     GetMacroModelData(const t_ModelDataKey & key)                           override;
protected:
  // [no protected members] -----------------------------
private:
  // main process loop
  std::function<void(std::function<void(size_t)>, ICFEXPNetClientNodeService &)> _main_loop;

  // connection data
  sockaddr_in _sock_server_adress;
  SOCKET      _socket;
  void create_socket();
  // messages for net communication
  CFEXPNETWinMessage::REQUEST  _req_message;
  CFEXPNETWinMessage::RESPONSE _res_message;
  // data for solver
  // data related to macro models
  std::atomic_bool          _new_macro_model;
  Ptr<t_ModelData>          _macro_model_data_map;

  // serialized data received
  // serialized data from fe nodes
  std::map<std::string, t_SerializedData> _serialize_calc_data_get_map;
  std::map<std::string, t_SerializedData> _serialize_calc_data_set_map;
};


class CFEXPNetServerWinClient
  : public ICFEXPNetServerClientNode<SOCKET>
{
public:
  CFEXPNetServerWinClient(SOCKET socket, std::string & ip, size_t id, std::string & server_ip,
     std::function<t_ENetThrdMsg    (size_t, size_t                                       )> message_gttr,
    std::function<bool              (size_t, size_t                                       )> message_lchr,
    std::function<void              (size_t, size_t                        , t_ENetThrdMsg)> message_sttr,
    std::function<Ptr<t_NetCalcData>(size_t                                               )> clcdata_gttr,
    std::function<void              (size_t                                               )> state_update,
    std::function<bool              (size_t                                               )> synchronizer,
    std::function<void              (size_t, t_fexpcommon_ct                              )> dtmacro_sttr,
    std::function<void              (size_t, Ptr<CFEXGeomTools::t_BoundBox>, size_t       )> mdmacro_sttr);
  virtual ~CFEXPNetServerWinClient();

  // override pure virtual member functions
  virtual void Run  () override;
  virtual void Close() override { close_connection(); }
protected:
  // [no protected members] -----------------------------
private:
  bool _calculation_started;

  // main client loop
  void main_loop            ();
  // close client socket connection
  void close_connection     ();
  // synchronization stages
  bool run_calc_synchr_stage(size_t stage);
  // client finishing
  void client_finishing     ();
  // calculation communication steps
  // load calc data from server
  Ptr<t_NetCalcData> get_server_data(bool wait_for_server_message = true);
  // initialize data procedure
  void load_model_data            (Ptr<t_NetCalcData> data);
  // control of calculation end
  bool calculation_end_control    (Ptr<t_NetCalcData> data);
  // control of process continue
  bool process_continue_control   (Ptr<t_NetCalcData> data);
  // control of calculation stability
  void stability_control          (Ptr<t_NetCalcData> data);
  // result for saving
  void simulation_results         (Ptr<t_NetCalcData> data);
  // data transfer based on server anysis
  void data_exchange_control      (Ptr<t_NetCalcData> data);
  void load_bounding_boxes        (Ptr<t_NetCalcData> data);
  void transfer_calc_data_request (Ptr<t_NetCalcData> data);
  void transfer_calc_data_response(Ptr<t_NetCalcData> data);
  // send data
  CFEXPNETWinMessage::REQUEST  _req_message;
  CFEXPNETWinMessage::RESPONSE _res_message;
};

#endif // !_CFEXPWINDOWSSOCKET_H_